home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2003 November A / PCWK1103A.iso / ABBYY FineReader 7.0 PRO / data1.cab / pdf_base.ps < prev    next >
Text File  |  2002-02-23  |  21KB  |  640 lines
  1. %    Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: pdf_base.ps,v 1.14.2.1 2002/02/22 19:45:55 ray Exp $
  17. % pdf_base.ps
  18. % Basic parser for PDF reader.
  19.  
  20. % This handles basic parsing of the file (including the trailer
  21. % and cross-reference table), as well as objects, object references,
  22. % streams, and name/number trees; it doesn't include any facilities for
  23. % making marks on the page.
  24.  
  25. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  26. .currentglobal true .setglobal
  27. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  28. pdfdict begin
  29.  
  30. % Define the name interpretation dictionary for reading values.
  31. /valueopdict mark
  32.   (<<) cvn { mark } bind    % don't push an actual mark!
  33.   (>>) cvn /.dicttomark load
  34.   ([) cvn { mark } bind        % ditto
  35.   (]) cvn dup load
  36. %  /true true        % see .pdfexectoken below
  37. %  /false false        % ibid.
  38. %  /null null        % ibid.
  39.   /F dup cvx        % see Objects section below
  40.   /R dup cvx        % see Objects section below
  41.   /stream dup cvx    % see Streams section below
  42. .dicttomark readonly def
  43.  
  44. % ------ Utilities ------ %
  45.  
  46. % Define a scratch string.  The PDF language definition says that
  47. % no line in a PDF file can exceed 255 characters.
  48. /pdfstring 255 string def
  49.  
  50. % Read the previous line of a file.  If we aren't at a line boundary,
  51. % read the line containing the current position.
  52. % Skip any blank lines.
  53. /prevline        % - prevline <startpos> <substring>
  54.  { PDFfile fileposition dup () pdfstring
  55.    2 index 257 sub 0 .max PDFfile exch setfileposition
  56.     {        % Stack: initpos linepos line string
  57.       PDFfile fileposition
  58.       PDFfile 2 index readline pop
  59.       dup length 0 gt
  60.        { 3 2 roll 5 -2 roll pop pop 2 index }
  61.        { pop }
  62.       ifelse
  63.         % Stack: initpos linepos line string startpos
  64.       PDFfile fileposition 5 index ge { exit } if
  65.       pop
  66.     }
  67.    loop pop pop 3 -1 roll pop
  68.  } bind def
  69.  
  70. % Handle the PDF 1.2 #nn escape convention when reading from a file.
  71. % This should eventually be done in C.
  72. /.pdffixname {            % <execname> .pdffixname <execname'>
  73.   PDFversion 1.2 ge {
  74.     dup .namestring (#) search {
  75.       name#escape cvn exch pop
  76.     } {
  77.       pop
  78.     } ifelse
  79.   } if
  80. } bind def
  81. /name#escape            % <post> <(#)> <pre> name#escape <string>
  82. { exch pop
  83.   1 index 2 () /SubFileDecode filter dup (x) readhexstring
  84.         % Stack: post pre stream char t/f
  85.   not { /.pdftoken cvx /syntaxerror signalerror } if
  86.   exch closefile concatstrings
  87.   exch 2 1 index length 2 sub getinterval
  88.   (#) search { name#escape } if concatstrings
  89. } bind def
  90.  
  91. % Execute a file, interpreting its executable names in a given
  92. % dictionary.  The name procedures may do whatever they want
  93. % to the operand stack.
  94. /.pdftokenerror {        % <count> <opdict> <errtoken> .pdftokenerror -
  95.   BXlevel 0 le {
  96.     (%stderr) (w) file
  97.     dup (****************Unknown operator: ) writestring
  98.     dup 2 index .writecvs dup (\n) writestring flushfile
  99.   } if pop pop
  100.   count exch sub { pop } repeat    % pop all the operands
  101. } bind def
  102. /.pdfexectoken {        % <count> <opdict> <exectoken> .pdfexectoken ?
  103.   DEBUG { dup == flush } if
  104.   2 copy .knownget {
  105.     exch pop exch pop exch pop exec
  106.   } {
  107.         % Normally, true, false, and null would appear in opdict
  108.         % and be treated as "operators".  However, there is a
  109.         % special fast case in the PostScript interpreter for names
  110.         % that are defined in, and only in, systemdict and/or
  111.         % userdict: putting these three names in the PDF dictionaries
  112.         % destroys this property for them, slowing down their
  113.         % interpretation in all PostScript code.  Therefore, we
  114.         % check for them explicitly here instead.
  115.     dup dup dup /true eq exch /false eq or exch /null eq or {
  116.       exch pop exch pop //systemdict exch get
  117.     } {
  118.       .pdftokenerror
  119.     } ifelse
  120.   } ifelse
  121. } bind def
  122. /.pdfrun {            % <file> <opdict> .pdfrun -
  123.     % Construct a procedure with the stack depth, file and opdict
  124.     % bound into it.
  125.   1 index cvlit count 2 sub 3 1 roll mark mark 5 2 roll
  126.   {    % Stack: ..operands.. count opdict file
  127.     token {
  128.       dup type /nametype eq {
  129.     dup xcheck {
  130.       .pdfexectoken
  131.     } {
  132.       .pdffixname
  133.       exch pop exch pop DEBUG { dup ==only ( ) print flush } if
  134.     } ifelse
  135.       } {
  136.     exch pop exch pop DEBUG { dup ==only ( ) print flush } if
  137.       } ifelse
  138.     } {
  139.       (%%EOF) cvn cvx .pdfexectoken
  140.     } ifelse
  141.   }
  142.   aload pop .packtomark cvx
  143.   /loop cvx 2 packedarray cvx
  144.   { stopped /PDFsource } aload pop
  145.   PDFsource
  146.   { store { stop } if } aload pop .packtomark cvx
  147.   /PDFsource 3 -1 roll store exec
  148. } bind def
  149.  
  150. % Execute a file, like .pdfrun, for a marking context.
  151. % This temporarily rebinds LocalResources and DefaultMatrix.
  152. /.pdfruncontext {        % <resdict> <file> <opdict> .pdfruncontext -
  153.   /.pdfrun load LocalResources DefaultMatrix
  154.   /LocalResources 7 -1 roll store
  155.   /DefaultMatrix matrix currentmatrix store
  156.   3 .execn
  157.   /DefaultMatrix exch store
  158.   /LocalResources exch store
  159. } bind def
  160.  
  161. % Get the depth of the PDF operand stack.  The main program (pdf_main.ps)
  162. % sets pdfemptycount before calling .pdfrun.
  163. /.pdfcount {        % - .pdfcount <count>
  164.   count pdfemptycount sub
  165. } bind def
  166.  
  167. % ------ File reading ------ %
  168.  
  169. % Read the cross-reference entry for an (unresolved) object.
  170. % The caller must save and restore the PDFfile position if desired.
  171. % For invalid (free) objects, we return 0.
  172. /readxrefentry        % <object#> readxrefentry <objpos>
  173.  { dup Objects exch lget
  174.    PDFfile exch setfileposition
  175.    PDFfile token pop        % object position
  176.    PDFfile token pop        % generation #
  177.    PDFfile token pop        % n or f
  178.    dup /n eq
  179.     { pop 1 add dup 255 gt
  180.        { Generations ltype /stringtype eq
  181.       {        % Convert Generations from a string to an array.
  182.         larray Generations llength lgrowto dup
  183.         0 1 2 index llength 1 sub
  184.          { Generations 1 index lget lput dup
  185.          }
  186.         for pop /Generations exch store
  187.       }
  188.      if
  189.        }
  190.       if
  191.     }
  192.     { /f eq
  193.        { pop 0 }
  194.        { /readxrefentry cvx /syntaxerror signalerror }
  195.       ifelse
  196.     }
  197.    ifelse
  198.         % Stack: obj# objpos 1+gen#
  199.    Generations 4 -1 roll 3 -1 roll lput
  200.  } bind def
  201.  
  202. % ================================ Objects ================================ %
  203.  
  204. % Since we may have more than 64K objects, we have to use a 2-D array to
  205. % hold them (and the parallel Generations structure).
  206. /lshift 9 def
  207. /lnshift lshift neg def
  208. /lsubmask 1 lshift bitshift 1 sub def
  209. /lsublen lsubmask 1 add def
  210. /larray {    % - larray <larray>
  211.   [ [] ]
  212. } bind def
  213. /lstring {    % - lstring <lstring>
  214.   [ () ]
  215. } bind def
  216. /ltype {    % <lseq> type <type>
  217.   0 get type
  218. } bind def
  219. /lget {        % <lseq> <index> lget <value>
  220.   dup //lsubmask and 3 1 roll //lnshift bitshift get exch get
  221. } bind def
  222. /lput {        % <lseq> <index> <value> lput -
  223.   3 1 roll
  224.   dup //lsubmask and 4 1 roll //lnshift bitshift get
  225.   3 1 roll put
  226. } bind def
  227. /llength {    % <lseq> llength <length>
  228.   dup length 1 sub dup //lshift bitshift
  229.   3 1 roll get length add
  230. } bind def
  231. % lgrowto assumes newlength > llength(lseq)
  232. /growto {    % <string/array> <length> growto <string'/array'>
  233.   1 index type /stringtype eq { string } { array } ifelse
  234.   2 copy copy pop exch pop
  235. } bind def
  236. /lgrowto {    % <lseq> <newlength> lgrowto <lseq'>
  237.     dup //lsubmask add //lnshift bitshift dup 3 index length gt {
  238.     % Add more sub-arrays.  Start by completing the last existing one.
  239.         % Stack: lseq newlen newtoplen
  240.     3 -1 roll dup llength 1 sub //lsubmask or 1 add lgrowto
  241.         % Stack: newlen newtoplen lseq
  242.     [ exch aload pop
  243.     counttomark 2 add -1 roll        % newtoplen
  244.     counttomark sub { dup 0 0 getinterval lsublen growto } repeat
  245.     dup 0 0 getinterval ] exch
  246.   } {
  247.     pop
  248.   } ifelse
  249.     % Expand the last sub-array.
  250.   1 sub //lsubmask and 1 add
  251.   exch dup dup length 1 sub 2 copy
  252.         % Stack: newsublen lseq lseq len-1 lseq len-1
  253.   get 5 -1 roll growto put
  254. } bind def
  255. /lforall {    % <lseq> <proc> lforall -
  256.   /forall cvx 2 packedarray cvx forall
  257. } bind def
  258.  
  259. % We keep track of PDF objects using the following PostScript variables:
  260. %
  261. %    Generations (lstring): Generations[N] holds 1+ the current
  262. %        generation number for object number N.  (As far as we can tell,
  263. %        this is needed only for error checking.)  For free objects,
  264. %        Generations[N] is 0.
  265. %
  266. %    Objects (larray): If object N is loaded, Objects[N] is the actual
  267. %        object; otherwise, Objects[N] is an executable integer giving
  268. %        the file offset of the object's entry in the cross-reference
  269. %        table.
  270. %
  271. %    GlobalObjects (dictionary): If object N has been resolved in
  272. %        global VM, GlobalObjects[N] is the same as Objects[N]
  273. %        (except that GlobalObjects itself is stored in global VM,
  274. %        so the entry will not be deleted at the end of the page).
  275. %
  276. %    IsGlobal (lstring): IsGlobal[N] = 1 iff object N was resolved in
  277. %        global VM.  This is an accelerator to avoid having to do a
  278. %        dictionary lookup in GlobalObjects when resolving every object.
  279.  
  280. % Initialize the PDF object tables.
  281. /initPDFobjects {        % - initPDFobjects -
  282.   /Objects larray def
  283.   /Generations lstring def
  284.   .currentglobal true .setglobal
  285.   /GlobalObjects 20 dict def
  286.   .setglobal
  287.   /IsGlobal lstring def
  288. } bind def
  289.  
  290. % Grow the tables to a specified size.
  291. /growPDFobjects {        % <minsize> growPDFobjects -
  292.   dup Objects llength gt {
  293.     dup Objects exch lgrowto /Objects exch def
  294.   } if
  295.   dup Generations llength gt {
  296.     dup Generations exch lgrowto /Generations exch def
  297.   } if
  298.   dup IsGlobal llength gt {
  299.     dup IsGlobal exch lgrowto /IsGlobal exch def
  300.   } if
  301.   pop
  302. } bind def
  303.  
  304. % We represent an unresolved object reference by a procedure of the form
  305. % {obj# gen# resolveR}.  This is not a possible PDF object, because PDF has
  306. % no way to represent procedures.  Since PDF in fact has no way to represent
  307. % any PostScript object that doesn't evaluate to itself, we can 'force'
  308. % a possibly indirect object painlessly with 'exec'.
  309. % Note that since we represent streams by executable dictionaries
  310. % (see below), we need both an xcheck and a type check to determine
  311. % whether an object has been resolved.
  312. /resolved? {        % <object#> resolved? <value> true
  313.             % <object#> resolved? false
  314.   Objects 1 index lget dup xcheck {
  315.     dup type /integertype eq {
  316.         % Check whether the object is in GlobalObjects.
  317.       pop IsGlobal 1 index lget 0 eq {
  318.     pop false
  319.       } {
  320.         % Update Objects from GlobalObjects
  321.     DEBUG { (%Global=>local: ) print dup == } if
  322.     GlobalObjects 1 index get dup Objects 4 1 roll lput true
  323.       } ifelse
  324.     } {
  325.       exch pop true
  326.     } ifelse
  327.   } {
  328.     exch pop true
  329.   } ifelse
  330. } bind def
  331. /oforce /exec load def
  332. /oget {        % <array> <index> oget <object>
  333.         % <dict> <key> oget <object>
  334.         % Before release 6.20, this procedure stored the resolved
  335.         % object back into the referring slot.  In order to support
  336.         % PDF linearization, we no longer do this.
  337.   get oforce
  338. } bind def
  339. % A null value in a dictionary is equivalent to an omitted key;
  340. % we must check for this specially.
  341. /knownoget {    % <dict> <key> knownoget <value> true
  342.         % <dict> <key> knownoget false
  343.         % See oget above regarding this procedure.
  344.   .knownget {
  345.     oforce dup null eq { pop false } { true } ifelse
  346.   } {
  347.     false
  348.   } ifelse
  349. } bind def
  350.  
  351. % PDF 1.1 defines a 'foreign file reference', but not its meaning.
  352. % Per the specification, we convert these to nulls.
  353. /F {        % <file#> <object#> <generation#> F <object>
  354.         % Some PDF 1.1 files use F as a synonym for f!
  355.    .pdfcount 3 lt { f } { pop pop pop null } ifelse
  356. } bind def
  357.  
  358. /checkgeneration {  % <object#> <generation#> checkgeneration <object#> <OK>
  359.   Generations 2 index lget 1 sub 1 index eq {
  360.     pop true
  361.   } {
  362.     QUIET not {
  363.       Generations 2 index lget 0 eq {
  364.     (Warning: reference to free object: )
  365.       } {
  366.     (Warning: wrong generation: )
  367.       } ifelse print 1 index =only ( ) print =only ( R) =
  368.     } {
  369.       pop
  370.     } ifelse false
  371.   } ifelse
  372. } bind def
  373. /R {        % <object#> <generation#> R <object>
  374.   /resolveR cvx 3 packedarray cvx
  375. } bind def
  376.  
  377. % If we encounter an object definition while reading sequentially,
  378. % we just store it away and keep going.
  379. /objopdict mark
  380.   valueopdict { } forall
  381.   /endobj dup cvx
  382. .dicttomark readonly def
  383. /obj {            % <object#> <generation#> obj <object>
  384.   PDFfile objopdict .pdfrun
  385. } bind def
  386. /endobj {        % <object#> <generation#> <object> endobj <object>
  387.   3 1 roll
  388.         % Read the xref entry if we haven't yet done so.
  389.         % This is only needed for generation # checking.
  390.   1 index resolved? {
  391.     pop
  392.   } {
  393.     PDFfile fileposition
  394.     2 index readxrefentry pop
  395.     PDFoffset add PDFfile exch setfileposition
  396.   } ifelse
  397.   checkgeneration {
  398.         % The only global objects we bother to save are
  399.         % (resource) dictionaries.
  400.     1 index dup gcheck exch type /dicttype eq and {
  401.       DEBUG { (%Local=>global: ) print dup == } if
  402.       GlobalObjects 1 index 3 index put
  403.       IsGlobal 1 index 1 put
  404.     } if
  405.     Objects exch 2 index lput
  406.   } {
  407.     pop pop null
  408.   } ifelse
  409. } bind def
  410.  
  411. % When resolving an object reference, we stop at the endobj.
  412. /resolveopdict mark
  413.   valueopdict { } forall
  414.   /endobj { endobj exit } bind
  415.                 % OmniForm generates PDF file with endobj missing in some
  416.                 % objects. AR ignores this. So we have to do it too.
  417.   /obj { pop pop endobj exit } bind
  418. .dicttomark readonly def
  419. /resolveR {        % <object#> <generation#> resolveR <object>
  420.   DEBUG { (%Resolving: ) print 2 copy 2 array astore == } if
  421.   1 index resolved? {
  422.     exch pop exch pop
  423.   } {
  424.     PDFfile fileposition 3 1 roll
  425.     1 index readxrefentry
  426.     3 1 roll checkgeneration {
  427.             % Stack: savepos objpos obj#
  428.      exch PDFoffset add PDFfile exch setfileposition
  429.      PDFfile token pop 2 copy ne
  430.       { (xref error!) = /resolveR cvx /rangecheck signalerror
  431.       }
  432.      if pop PDFfile token pop
  433.      PDFfile token pop /obj ne
  434.       { (xref error!) = /resolveR cvx /rangecheck signalerror
  435.       }
  436.      if
  437.      pdf_run_resolve    % PDFfile resolveopdict .pdfrun
  438.     }
  439.     {        % Don't cache if the generation # is wrong.
  440.      pop pop null
  441.     } ifelse
  442.     exch PDFfile exch setfileposition
  443.   } ifelse
  444. } bind def      
  445.  
  446. % ================================ Streams ================================ %
  447.  
  448. % We represent a stream by an executable dictionary that contains,
  449. % in addition to the contents of the original stream dictionary:
  450. %    /File - the file or string where the stream contents are stored,
  451. %      if the stream is not an external one.
  452. %    /FilePosition - iff File is a file, the position in the file
  453. %      where the contents start.
  454. %    /StreamKey - the key used to decrypt this stream, if any.
  455. % We do the real work of constructing the data stream only when the
  456. % contents are needed.
  457.  
  458. % Construct a stream.  The length is not reliable in the face of
  459. % different end-of-line conventions, but it's all we've got.
  460. %
  461. % PDF files are inconsistent about what may fall between the 'stream' keyword
  462. % and the actual stream data, and it appears that no one algorithm can
  463. % detect this reliably.  We used to try to guess whether the file included
  464. % extraneous \r and/or \n characters, but we no longer attempt to do so,
  465. % especially since the PDF 1.2 specification states flatly that the only
  466. % legal terminators following the 'stream' keyword are \n or \r\n, both of
  467. % which are properly skipped and discarded by the token operator.
  468. /stream {    % <dict> stream <modified_dict>
  469.   dup /F known dup PDFsource PDFfile eq or {
  470.     not {
  471.       dup /File PDFfile put
  472.       dup /FilePosition PDFfile fileposition put
  473.       DEBUG { (%FilePosition: ) print dup /FilePosition get == } if
  474.     } if
  475.     PDFfile fileposition 1 index /Length oget add
  476.       PDFfile exch setfileposition
  477.   } {
  478.     pop
  479.     % We're already reading from a stream, which we can't reposition.
  480.     % Capture the sub-stream contents in a string.
  481.     dup /Length oget string PDFsource exch readstring
  482.     not {
  483.       (Unexpected EOF in stream!) =
  484.       /stream cvx /rangecheck signalerror
  485.     } if
  486.     1 index exch /File exch put
  487.   } ifelse
  488.   PDFsource token pop
  489.     /endstream ne { /stream cvx /syntaxerror signalerror } if
  490.   cvx
  491. } bind def
  492. /endstream {
  493.   exit
  494. } bind def
  495.  
  496. % Contrary to the published PDF (1.3) specification, Acrobat Reader
  497. % accepts abbreviated filter names everywhere, not just for in-line images,
  498. % and some applications (notably htmldoc) rely on this.
  499. /unabbrevfilterdict mark
  500.   /AHx /ASCIIHexDecode  /A85 /ASCII85Decode  /CCF /CCITTFaxDecode
  501.   /DCT /DCTDecode  /Fl /FlateDecode  /LZW /LZWDecode  /RL /RunLengthDecode
  502. .dicttomark readonly def
  503.  
  504. % Extract and apply filters.
  505. /filterparms {        % <dict> <DPkey> <Fkey> filterparms
  506.             %   <dict> <parms> <filternames>
  507.   2 index exch .knownget {
  508.     exch 2 index exch .knownget {
  509.         % Both filters and parameters.
  510.       exch dup type /nametype eq {
  511.     1 array astore exch 1 array astore exch
  512.       } if
  513.     } {
  514.         % Filters, but no parameters.
  515.       null exch
  516.       dup type /nametype eq { 1 array astore } if
  517.     } ifelse
  518.   } {
  519.         % No filters: ignore parameters, if any.
  520.     pop null { }
  521.   } ifelse
  522. } bind def
  523. /filtername {        % <filtername> filtername <filtername'>
  524.   //unabbrevfilterdict 1 index .knownget { exch pop } if
  525. } bind def
  526. /applyfilters {        % <parms> <source> <filternames> applyfilters <stream>
  527.   2 index null eq {
  528.     { filtername filter }
  529.   } {
  530.     {        % Stack: parms stream filtername
  531.       2 index 0 oget dup null eq { pop } { exch } ifelse filtername filter
  532.       exch dup length 1 sub 1 exch getinterval exch
  533.     }
  534.   } ifelse forall exch pop
  535. } bind def
  536.  
  537. % Resolve a stream dictionary to a PostScript stream.
  538. % Streams with no filters require special handling:
  539. %    - If we are going to interpret their contents, we let endstream
  540. %      terminate the interpretation loop;
  541. %    - If we are just going to read data from them, we impose
  542. %      a SubFileDecode filter that reads just the requisite amount of data.
  543. % Note that, in general, resolving a stream repositions PDFfile.
  544. % Clients must save and restore the position of PDFfile themselves.
  545. /resolvestream {    % <streamdict> <readdata?> resolvestream <stream>
  546.   1 index /F .knownget {
  547.         % This stream is stored on an external file.
  548.     (r) file 3 -1 roll
  549.     /FDecodeParms /FFilter filterparms
  550.         % Stack: readdata? file dict parms filternames
  551.     4 -1 roll exch
  552.     pdf_decrypt_stream
  553.     applyfilters
  554.   } {
  555.     exch dup /FilePosition .knownget {
  556.       1 index /File get exch setfileposition
  557.     } if
  558.         % Stack: readdata? dict
  559.     /DecodeParms /Filter filterparms
  560.         % Stack: readdata? dict parms filternames
  561.     2 index /File get exch
  562.         % Stack: readdata? dict parms file/string filternames
  563.     pdf_decrypt_stream        % add decryption if needed
  564.     dup length 0 eq {
  565.         % All the PDF filters have EOD markers, but in this case
  566.         % there is no specified filter.
  567.       pop exch pop
  568.         % Stack: readdata? dict file/string
  569.       2 index {
  570.         % We're going to read data; use a SubFileDecode filter.
  571.     1 index /Length oget () /SubFileDecode filter
  572.       } {
  573.     dup type /filetype ne {
  574.         % Use a SubFileDecode filter to read from a string.
  575.       0 () /SubFileDecode filter
  576.     } if
  577.       } ifelse
  578.     } {
  579.       applyfilters
  580.     } ifelse
  581.   } ifelse
  582.         % Stack: readdata? dict file
  583.   exch pop exch pop
  584. } bind def
  585.  
  586. % ============================ Name/number trees ============================ %
  587.  
  588. /nameoget {        % <nametree> <key> nameoget <obj|null>
  589.   exch /Names exch .treeget
  590. } bind def
  591.  
  592. /numoget {        % <numtree> <key> numoget <obj|null>
  593.   exch /Nums exch .treeget
  594. } bind def
  595.  
  596. /.treeget {        % <key> <leafkey> <tree> .treeget <obj|null>
  597.   dup /Kids knownoget {
  598.     exch pop .branchget
  599.   } {
  600.     exch get .leafget
  601.   } ifelse
  602. } bind def
  603.  
  604. /.branchget {        %  <key> <leafkey> <kids> .branchget <obj|null>
  605.   dup length 0 eq {
  606.     pop pop pop null
  607.   } {
  608.     dup length -1 bitshift 2 copy oget
  609.             % Stack: key leafkey kids mid kids[mid]
  610.     dup /Limits oget aload pop
  611.             % Stack: key leafkey kids mid kids[mid] min max
  612.     6 index lt {
  613.       pop pop
  614.       1 add 1 index length 1 index sub getinterval .branchget
  615.     } {
  616.       5 index gt {
  617.     pop
  618.     0 exch getinterval .branchget
  619.       } {
  620.     exch pop exch pop .treeget
  621.       } ifelse
  622.     } ifelse
  623.   } ifelse
  624. } bind def
  625.  
  626. /.leafget {        % <key> <pairs> .leafget <obj|null>
  627.   dup length 2 eq {
  628.     dup 0 get 2 index eq { 1 oget } { pop null } ifelse
  629.     exch pop
  630.   } {
  631.     dup length -1 bitshift -2 and 2 copy oget
  632.             % Stack: key pairs mid pairs[mid]
  633.     3 index gt { 0 exch } { 1 index length 1 index sub } ifelse
  634.     getinterval .leafget
  635.   } ifelse
  636. } bind def
  637.  
  638. end            % pdfdict
  639. .setglobal
  640.